package ConCurrent;

import java.util.concurrent.CountDownLatch;

/**
 * 如何保证三个线程同时执行
 *
 * 思路： 使用CountDownLatch
 * `CountDownLatch` 是一个同步辅助类，它允许一个或多个线程等待其他线程完成操作。我们可以利用 `CountDownLatch` 来实现三个线程的同步启动。
 *  创建一个`CountDownLatch`对象，并设置初始计数值为1
 *  创建三个线程，每个线程都进入等待状态，当主线程调用 `countDown()` 方法，将计数值减1，才释放所有线程，达到同步启动的效果。
 *
 *  **CountDownLatch**：
 *    - 创建一个 `CountDownLatch` 对象，初始计数为 1。
 *    - 每个线程在开始执行前调用 `latch.await()`，等待计数器归零。
 *    - 主线程在所有子线程准备好后调用 `latch.countDown()`，使计数器归零，所有等待的线程继续执行。
 *
 */
public class ThreadAllStart {

    public static void main(String[] args) {
        //创建一个 CountDownLatch，计数为 1
        CountDownLatch latch = new CountDownLatch(1);

        //创建三个线程
        Thread threadA = new Thread(() -> {
            try {
                // 等待计数器归0
                latch.await();
                System.out.println("Thread A started");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });

        Thread threadB = new Thread(() -> {
            try {
                latch.await();
                System.out.println("Thread  B  started");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });

        Thread threadC = new Thread(() -> {
            try {
                latch.await();
                System.out.println("Thread C started");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });

        // 线程启动
        threadA.start();
        threadB.start();
        threadC.start();

        // 主线程等待一段时间，确保所有子线程都准备好
        try {
            Thread.sleep(1000); // 模拟准备时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 释放所有等待的线程
        latch.countDown();
        System.out.println("All threads start now");
    }
}
